import { nanoid10 } from "../../../tools/Tools";
import { getDevTableData } from "./HandSonGridToolService/getDataSourceService";
//声明type为row和col的枚举
export var DynamicType;
(function (DynamicType) {
    DynamicType["row"] = "row";
    DynamicType["col"] = "col";
})(DynamicType || (DynamicType = {}));
// 1. 动态行匹配列，需要判断两个表中的列类型是否一致，如果不一致，就不能作匹配；
// 2. 动态列： 动态列插进来的表头，里面有一个属性 config:{ ht: 2,type:”numeric”} , 要通过表格数据的第一行数据类型去判断设置。
//     type  =  numeric / text      ---- ht:1 文本 左对齐； ht:2 数值 右对齐  ht:3 居中对齐
//        1） "" = text
//        2）数字 / null = numeric类型
// 这两个判断条件要写在解析器中。
// 还要写一个公共函数，例; checkType(){}
//定义Dr公式解析器, 动态行公式
export const parseDrFormula = async (type, // 判断是行动态还是列动态
index, // cpas表中选择的行列索引位置
params, lastLogicData, // cpas表数据
context // cpas表数据
) => {
    let listData = []; //dev表数据
    listData = await getDevTableData(params[0].dataList, params[0].dataId, params[0].dbName, params[0].fields, params[0].where, params[0].order, false, 0);
    //表头类型
    let colDataType = await getDevTableData(params[0].dataList, params[0].dataId, params[0].dbName, params[0].fields, params[0].where, params[0].order, true, 0);
    console.log("333--列动态", listData, colDataType);
    //业务逻辑拼装好的数据源, 直接操作该应用进行动态修改数据
    let logicData = lastLogicData;
    const { data, header } = logicData; // cpas表数据
    //获取公式行的数据
    const formulaRow = data[index];
    //获取公式行的配置,因为公式行要被替换数据。通过复制公式行的配置，来保证标识公式行.
    const formulaConfig = JSON.parse(formulaRow[formulaRow.length - 1]);
    const { formula, formulaState, rId, ...objRest } = formulaConfig;
    let zeroData;
    if (listData.length > 0) {
        zeroData = listData.map((item, n) => {
            let arr = Array.from({ length: logicData.header.length - 2 }, () => null); // 建立dev表一行空的数据
            let keyId = Object.values(item);
            arr.unshift(keyId[0].toString());
            let obj = {
                rId: nanoid10(),
                ...objRest,
            };
            arr.push(JSON.stringify(obj));
            return arr;
        });
        // cpas data中有公式的那一行要依然带着公式，其它动态生成出来的数据不用带公式，但是都需要带上标签属性
        data.splice(index, 1, [...zeroData[0], JSON.stringify(formulaConfig)]);
        zeroData.splice(0, 1);
        data.splice(index + 1, 0, ...zeroData);
    }
    else {
        return;
    }
    let devItemArr = [];
    for (let i = 0; i < params[1].length; i++) {
        let temp = params[1][i];
        listData.map((list) => {
            let arrs = Object.values(list);
            devItemArr.push(arrs[temp.devIndex]);
            return devItemArr;
        });
    }
    let qq = devItemArr.slice(0, listData.length);
    function toTwoDimArray(arr, numRows) {
        var result = [];
        for (var i = 0; i < arr.length; i = i + numRows) {
            result.push(arr.slice(i, i + numRows));
        }
        return result;
    }
    var result = toTwoDimArray(devItemArr, qq.length);
    result.forEach(function (re, i) {
        re.forEach(function (r, j) {
            data.forEach(function (dat, k) {
                if (k >= Number(j + index) && k < Number(re.length + index)) {
                    dat.splice(params[1][i].cpasIndex, 1, r);
                }
            });
        });
    });
    /***** start 608 */
    header.map((head) => {
        params[1].map((gx) => {
            if (head.label === gx.sourceMap) {
                head.config.matchDynamic = true;
            }
            else {
                return;
            }
        });
        return head;
    });
    /***** end 608 */
    let asyncRowidx = [];
    let cpasDev = params[1]; // 两表的关系
    let newdevDatas2 = [];
    for (let items of cpasDev) {
        const newdevDatas = listData.map((ite, index) => {
            const valArr = Object.values(ite);
            let str = valArr[items.devIndex] || "0";
            return str;
        });
        newdevDatas2 = newdevDatas;
        // 生成动态行坐标范围
        let keyid = Object.keys(newdevDatas);
        asyncRowidx = keyid.map((kd) => {
            return Number(kd) + index;
        });
    }
    data.map((item, i) => {
        i === index ? item.splice(item.length - 2, 1) : item;
        return item;
    });
    let firstPos = index;
    let endPos = Number(newdevDatas2.length - 1 + index);
    //动态标记行,公式行不标记
    context.logicFormulaService.setDynamicRowsOrColumns("row", asyncRowidx, logicData);
    // console.log("333--行动态坐标", firstPos, endPos, asyncRowidx);
    return { type, start: firstPos, end: endPos };
};
//定义Dc公式解析器, 动态列公式
export const parseDcFormula = async (type, index, params, lastLogicData, context) => {
    let listData = []; //dev表数据
    listData = await getDevTableData(params[0].dataList, params[0].dataId, params[0].dbName, params[0].fields || [], "", params[0].order || "", false, 0);
    //拿表头类型
    let colDataType = await getDevTableData(params[0].dataList, params[0].dataId, params[0].dbName, params[0].fields || [], "", params[0].order || "", true, 0);
    console.log("333--colDataType", colDataType);
    //业务逻辑拼装好的数据源
    let logicData = lastLogicData;
    //TODO 注意这里是树，需要递归处理
    const { header, data } = logicData;
    //************* start dev表格表头，从接口动态取值,进行组装 */
    //  先拿到dev表的表头，不包含“项目”这一列
    const columnDas = [];
    if (listData.length > 0) {
        for (let i = 0; i < Object.keys(listData[0]).length; i++) {
            if (i > 0) {
                let ss = Object.values(listData[0]);
                let sa = ss.map((item) => {
                    let fieldType = typeof item;
                    return fieldType;
                });
                columnDas.push({
                    dataField: Object.keys(listData[0])[i],
                    caption: Object.keys(listData[0])[i],
                    // fixed: false,
                    fieldType: sa[i],
                });
            }
        }
    }
    else {
        return;
    }
    let gs = header[index].config;
    const { formula, formulaState, ...objRest } = gs;
    colDataType.splice(0, 1);
    const cols = [];
    colDataType.map((item, index) => {
        item.FieldType === "number"
            ? (objRest.type = "numeric")
            : (objRest.type = "text");
        const headObj = {
            // config: { width: 150, type: "text", ht: 2, keyword: true },  //  数字 / null = numeric类型 ; "" = text
            config: {
                width: objRest.width,
                type: objRest.type,
                ht: objRest.ht,
            },
            key: nanoid10(),
            label: item.FieldName,
        };
        cols.push(headObj);
    });
    // //获取公式行的数据
    const formulaColumn = header[index];
    // 处理公式列
    // header.splice(index, 1, formulaColumn); // 公式列删除再替换
    header.splice(index, 1, {
        key: formulaColumn.key,
        config: { ...formulaColumn.config },
        label: cols[0].label,
    }); // 公式列删除再替换
    //除了公式列以外的其他列
    cols.splice(0, 1);
    header.splice(index + 1, 0, ...cols);
    const zeroData = Array.from({ length: columnDas.length }, () => null);
    data.map((item) => {
        item.splice(index, 1);
        item.splice(index, 0, ...zeroData);
        return item;
    });
    let cpasDev = params[1]; // 两表的关系
    for (let n in cpasDev) {
        let valArr = [];
        const newdevDatas = listData.map((ite, i) => {
            valArr = Object.values(ite);
            valArr.shift();
            return i === cpasDev[n].devIndex ? valArr : zeroData;
        });
        let ss = newdevDatas.splice(cpasDev[n].devIndex, 1); // 取出对应关系的那一行数据
        data.map((temp, i) => {
            return i === cpasDev[n].cpasIndex
                ? temp.splice(index, ss[0].length, ...ss[0])
                : temp;
        });
    }
    let colArr = [];
    columnDas.forEach((item) => {
        colArr.push(item.caption);
    });
    data[0].splice(index, colArr.length, ...colArr);
    data.map((dat) => {
        params[1].map((gx) => {
            if (dat[0] === gx.sourceMap) {
                let sa = JSON.parse(dat[dat.length - 1]);
                sa.matchDynamic = true;
                dat.splice(dat.length - 1, 1, JSON.stringify(sa));
            }
            else {
                return;
            }
        });
        return dat;
    });
    //计算动态添加列的结束索引
    let len = logicData.header.length;
    let lastPos = len - index - columnDas.length;
    // 需要计算动态列添加的范围
    let DynamicColumn = [];
    let endColIndex = len - lastPos - 1;
    let keyid = Object.keys(columnDas);
    DynamicColumn = keyid.map((kd) => {
        return Number(kd) + index;
    });
    //动态标记列
    context.logicFormulaService.setDynamicRowsOrColumns("column", DynamicColumn, logicData);
    return { type, start: index, end: endColIndex };
};
